package com.example.custom.web.task;

import com.example.custom.web.entity.DeptTree;
import com.example.custom.web.entity.DeptTreeResponseClass;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.example.custom.web.entity.UserInfo;
import com.example.custom.web.entity.UserResponseClass;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.HttpMethod;

import java.math.BigInteger;
import java.security.MessageDigest;

import java.util.ArrayList;
import java.util.List;


/**
 * @descriptions:
 * @author: otitan-jianghongkai
 * @date: 2024/1/4 14:22
 * @version: 1.0
 */
@Component
public class ScheduledTask {


    //    @Value("${api.getTokenApiUrl}")
//    private static String getTokenApiUrl;
//
//    @Value("${api.shiCloudUserApiUrl}")
//    private static String shiCloudUserApiUrl;
//
//    @Value("${api.deptTreeApiUrl}")
//    private static String deptTreeApiUrl;
//
//    @Value("${parameter.appId}")
//    private static String appId;
//
//    @Value("${parameter.loginId}")
//    private static String loginId;
//
//    @Value("${parameter.deptId}")
//    private static String deptId;
    private static final String GET_TOKEN_API_URL = "https://fmisoad.app.com.cn/ssologin/getToken";
    private static final String SHICLOUD_USER_API_URL = "http://gateway.fmisd.app.com.cn/blade-bus-common/yg/shiCloudUser";
    private static final String DEPTTREE_API_URL = "http://gateway.fmisd.app.com.cn/blade-bus-common/hrmDepart/getDeptTree";
    private static final String appId = "TT";
    private static final String loginId = "96000757";
    private static final String deptId = "1021";

    // @Scheduled(cron = "${task.syncCron}")
    public static void main(String[] args) {
        //  创建RestTemplate实例以发送HTTP请求
        RestTemplate restTemplate = new RestTemplate();
        // TODO 第一步，获取token
        // 准备请求头， 设置请求头内容类型为application/x-www-form-urlencoded，以便正确传递POST请求中的URL-encoded参数
        HttpHeaders getTokenHeaders = new HttpHeaders();
        getTokenHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        // 准备请求体（form-urlencoded格式）,创建包含appid和loginid的请求参数集合
        MultiValueMap<String, String> getTokenParams = new LinkedMultiValueMap<>();
        getTokenParams.add("appid", appId);
        getTokenParams.add("loginid", loginId);
        // 构造请求实体
        HttpEntity<MultiValueMap<String, String>> getTokenRequest = new HttpEntity<>(getTokenParams, getTokenHeaders);

        // 创建并发送POST请求
        ResponseEntity<String> tokenResponse = restTemplate.postForEntity(GET_TOKEN_API_URL, getTokenRequest, String.class);

        // 检查响应状态码，然后返回token或者其他你需要的数据
        if (tokenResponse.getStatusCode().is2xxSuccessful()) {
            String token = tokenResponse.getBody();
            System.out.println(token);
            // TODO 第二步：使用获取到的token调用用户信息接口
            // 设置请求头，将token分别放入Blade-Auth-Ecology
            HttpHeaders shiCloudUserHeaders = new HttpHeaders();
            //shiCloudUserHeaders.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
            shiCloudUserHeaders.set("Blade-Auth-Ecology", token);

            //URL接口中拼接请求参数
            String shiCloudUserUrl = SHICLOUD_USER_API_URL + "?deptId=" + deptId;
            // 创建并发送GET请求
            ResponseEntity<String> userResponse = restTemplate.exchange(shiCloudUserUrl, HttpMethod.GET, new HttpEntity<>(null, shiCloudUserHeaders), String.class);
            //定义一个存储用户数据信息的集合
            List<UserInfo> userInfoList;
            if (userResponse.getStatusCode().is2xxSuccessful()) {
                try {
                    ObjectMapper mapper = new ObjectMapper();
                    if (userResponse.getBody() != null) {
                        System.out.println(userResponse.getBody());
                        UserResponseClass response = mapper.readValue(userResponse.getBody(), UserResponseClass.class);
                        userInfoList = response.getData();  // 假设YourResponseClass中有getData()方法返回List<UserInfo>
                        System.out.println(userInfoList);
                        // TODO userInfoList中存储的是将要存储在etcd数据库中的新数据，要先把etcd中的旧数据删除。
                        // TODO 存储用户信息
//                        for (UserInfo user : userInfoList) {
//                            // 这里做对用户信息数据的处理逻辑（数据入库）
//                        }
                    } else {
                        throw new RuntimeException("调用用户信息接口返回数据为空");
                    }
                } catch (Exception e) {
                    throw new RuntimeException("解析调用用户信息接口返回的用户信息时遇到了问题: " + e.getMessage());
                }
            } else {
                throw new RuntimeException("调用用户信息接口遇到错误。 Status code: " + userResponse.getStatusCode());
            }

            // TODO 第三步：使用获取到的token调用组织结构接口
            // 设置请求头，将token分别放入Blade-Auth-Ecology
            HttpHeaders deptTreeHeaders = new HttpHeaders();
            deptTreeHeaders.set("Blade-Auth-Ecology", token);

            //URL接口中拼接请求参数
            String deptTreeUrl = DEPTTREE_API_URL + "?deptId=" + deptId;
            // 创建并发送GET请求
            ResponseEntity<String> deptTreeResponse = restTemplate.exchange(deptTreeUrl, HttpMethod.GET, new HttpEntity<>(null, deptTreeHeaders), String.class);

            if (deptTreeResponse.getStatusCode().is2xxSuccessful()) {
                try {

                    if (deptTreeResponse.getBody() != null) {
                        // 创建ObjectMapper实例以解析JSON响应
                        ObjectMapper mapper = new ObjectMapper();
                        System.out.println(deptTreeResponse.getBody());
                        JsonNode rootNode = mapper.readTree(deptTreeResponse.getBody());
                        JsonNode dataNode = rootNode.get("data");

                        // 创建一个列表来存储所有部门（包括顶层和子部门）
                        List<DeptTree> deptTreeList = new ArrayList<>();

                        // 遍历顶级部门，将其添加到allDepartments中，并处理子部门
//                        for (JsonNode deptNode : dataNode) {
//                            DeptTree department = mapper.convertValue(deptNode, DeptTree.class);
                        handleSubDepartments(dataNode, mapper, deptTreeList); // 更新参数传递给handleSubDepartments方法
//                        }
                        //TODO deptTreeList 就是完整的数据
                        System.out.println(deptTreeList);
                        System.out.println(deptTreeList.size());
                        // 这里做对组织结构数据的处理逻辑（数据入库）

                    } else {
                        throw new RuntimeException("掉用组织结构接口返回数据为空");
                    }
                } catch (Exception e) {
                    throw new RuntimeException("解析调用组织结构接口返回的用户信息时遇到了问题: " + e.getMessage());
                }
            } else {
                throw new RuntimeException("调用组织结构接口遇到错误。 Status code: " + deptTreeResponse.getStatusCode());
            }
        } else {
            throw new RuntimeException("调用获取token接口遇到错误。 Status code: " + tokenResponse.getStatusCode());
        }

    }

    /**
     * 递归处理组织结构数据
     */
    private static void handleSubDepartments(JsonNode node, ObjectMapper mapper, List<DeptTree> deptTreeList) throws JsonProcessingException {
        for (JsonNode deptNode : node) {
            DeptTree deptTree = mapper.convertValue(deptNode, DeptTree.class);
            deptTreeList.add(deptTree);

            // 如果当前节点包含子部门，则递归处理子部门
            if (deptNode.has("children") && !deptNode.get("children").isEmpty()) {
                handleSubDepartments(deptNode.get("children"), mapper, deptTreeList);
            }
        }
    }


    public static String EncodeByMD5(String str) {
        try {
            // 生成一个MD5加密计算摘要
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 计算md5函数
            md.update(str.getBytes("UTF-8"));
            // digest()最后确定返回md5 hash值，返回值为8为字符串。因为md5 hash值是16位的hex值，实际上就是8位的字符
            // BigInteger函数则将8位的字符串转换成16位hex值，用字符串来表示；得到字符串形式的hash值
            String md5 = new BigInteger(1, md.digest()).toString(16);
            //BigInteger会把0省略掉，需补全至32位
            return fillMD5(md5);
        } catch (Exception e) {
            throw new RuntimeException("MD5加密错误:" + e.getMessage(), e);
        }
    }

    private static String fillMD5(String md5) {
        //如果不够32位则回调自身补零，最后返回32位长度的签名
        String str = md5.length() == 32 ? md5 : fillMD5("0" + md5);
        str.toUpperCase();
        return str.toUpperCase();
    }

//    public static void main(String[] args) {
//        String pass = "CBE2EE39543F3FC220D4AE24A3B6B5C7";
//        String passStr = "Acf@12345";
//        System.out.println(EncodeByMD5(passStr));
//    }
}
